package 力扣.中等;

import java.util.*;

/*
* 现在有一个特殊的排名系统，依据参赛团队在投票人心中的次序进行排名，每个投票者都需要按从高到低的顺序对参与排名的所有团队进行排位。

排名规则如下：

参赛团队的排名次序依照其所获「排位第一」的票的多少决定。如果存在多个团队并列的情况，将继续考虑其「排位第二」的票的数量。以此类推，直到不再存在并列的情况。
如果在考虑完所有投票情况后仍然出现并列现象，则根据团队字母的字母顺序进行排名。
给你一个字符串数组 votes 代表全体投票者给出的排位情况，请你根据上述排名规则对所有参赛团队进行排名。

请你返回能表示按排名系统 排序后 的所有团队排名的字符串。

 

示例 1：

输入：votes = ["ABC","ACB","ABC","ACB","ACB"]
输出："ACB"
解释：A 队获得五票「排位第一」，没有其他队获得「排位第一」，所以 A 队排名第一。
B 队获得两票「排位第二」，三票「排位第三」。
C 队获得三票「排位第二」，两票「排位第三」。
由于 C 队「排位第二」的票数较多，所以 C 队排第二，B 队排第三。
示例 2：

输入：votes = ["WXYZ","XYZW"]
输出："XWYZ"
解释：X 队在并列僵局打破后成为排名第一的团队。X 队和 W 队的「排位第一」票数一样，但是 X 队有一票「排位第二」，而 W 没有获得「排位第二」。
示例 3：

输入：votes = ["ZMNAGUEDSJYLBOPHRQICWFXTVK"]
输出："ZMNAGUEDSJYLBOPHRQICWFXTVK"
解释：只有一个投票者，所以排名完全按照他的意愿。
示例 4：

输入：votes = ["BCA","CAB","CBA","ABC","ACB","BAC"]
输出："ABC"
解释：
A 队获得两票「排位第一」，两票「排位第二」，两票「排位第三」。
B 队获得两票「排位第一」，两票「排位第二」，两票「排位第三」。
C 队获得两票「排位第一」，两票「排位第二」，两票「排位第三」。
完全并列，所以我们需要按照字母升序排名。
示例 5：

输入：votes = ["M","M","M","M"]
输出："M"
解释：只有 M 队参赛，所以它排名第一。
*
*
* 我的思路是：不用统计每次排名的次数 第一和第二都有一个分值  最后比较总的分值即可
*           但是分值的确定必须保证互不影响
*总结：char数组比较器要先转换成list数组来写
*
* 大佬的思路：自己写一个比较器
* //用于记录：每个字符对应的数组记录着每次的rank次数
        Map<Character,int[]> map = new HashMap<>();
        //第一次还没有创建数组，先遍历一遍初始化map并创建数组
        for(int i = 0;i < votes[0].length();i++) {
            int[] rank = new int[26];
            rank[i]++;
            map.put(votes[0].charAt(i),rank);
        }
        //记录，第一个已经记录过了
        for(int i = 1;i < votes.length;i++) {
            for(int j = 0;j < votes[i].length();j++) {
                map.get(votes[i].charAt(j))[j]++;
            }
        }
        //将map拆分成entry放在list里面
        List<Map.Entry<Character,int[]>> list = new ArrayList<>(map.entrySet());

        //调用接口排序
        Collections.sort(list,new Comparator<Map.Entry<Character,int[]>>() {
        //想让a排在b前，返回值必须为负数。
        //而a排在b前的条件是：a的rank“分数”比b高
            public int compare(Map.Entry<Character,int[]> a,
                Map.Entry<Character,int[]> b){
                for(int i = 0;i < 26;i++) {
                    if(a.getValue()[i] > b.getValue()[i]){
                        return -1;
                    }else if(a.getValue()[i] < b.getValue()[i]){
                        return 1;
                    }
                }
                //rank分都一样的情况，比“血统”。ascii码靠前的比较“强”
                return a.getKey() - b.getKey();
            }
        });
        //拼接一下结果
        StringBuilder ans = new StringBuilder();

        for(int i = 0;i < list.size();i++){
            ans.append(list.get(i).getKey());
        }

        return ans.toString();
*/
public class 投票给队伍排名 {
    public static void main(String[] args) {
        String[] votes = {"BCA","CAB","CBA","ABC","ACB","BAC"};

//        if (votes.length == 1 || votes[0].equals(votes[1])) {
//            System.out.println(votes[0]);
//        } else {
//            Map<Character, Double> map = new HashMap<>();
//            for (int i = 0; i < votes[0].length(); i++) {
//
//                map.put(votes[0].charAt(i), 0.0);
//            }
//
//            int max = 20000;
//            for (String vote : votes) {
//                for (int i = 0; i < vote.length(); i++) {
//                    for (Map.Entry<Character, Double> entry : map.entrySet()) {
//                        if (entry.getKey().equals(vote.charAt(i))) {
//                            entry.setValue(entry.getValue() + (vote.length() - i) * max);
//
//
//                        }
//                    }
//
//                    max = max / 5;
//                }
//                max = 20000;
//            }
//
//            ArrayList<Double> a=new ArrayList<>();
//            for (Double value : map.values()) {
//                a.add(value);
//            }
//
//            if(a.get(0)==a.get(1)){
//                char[] chars = votes[0].toCharArray();
//                Arrays.sort(chars);
//                System.out.println(chars);
//            }
//
//            a.sort(Comparator.reverseOrder());
//
//
//
//
//            char[] aop=new char[votes[0].length()];
//
//            for(int i=0;i<a.size();i++){
//                for (Character key : map.keySet()) {
//                  if(map.get(key)==a.get(i)){
//                      aop[i]=key;
//
//                  }
//                }
//
//
//            }
//            String c=new String(aop);
//            System.out.println(c);
//
//
//
//
//
//        }
         HashMap<Character,int[]> map=new HashMap<>();
        for (String vote : votes) {
            for (int i = 0; i < vote.length(); i++) {
                int[] rankArr = map.getOrDefault(vote.charAt(i), new int[26]);
                rankArr[i]++;
                map.put(vote.charAt(i), rankArr);
            }
        }
       List<Character> list=new ArrayList<>();
        for(int i=0;i<votes[0].length();i++){
            list.add(votes[0].charAt(i));
        }

        Collections.sort(list, new Comparator<Character>() {
            @Override
            public int compare(Character o1, Character o2) {
                for(int i=0;i<26;i++){
                    if(map.get(o1)[i]>map.get(o2)[i]){
                        return -1;
                    }
                    if(map.get(o1)[i]<map.get(o2)[i]){
                        return 1;
                    }

                }
                return  o1.charValue()-o2.charValue();

            }
        });
        System.out.println(list.toString());
        StringBuilder ans = new StringBuilder();

        for(int i = 0;i < list.size();i++){
            ans.append(list.get(i));
        }


    }
}

